{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Twin Delated DDPG  (TD3) with TensorFlow\n",
    "\n",
    "In this notebook we will look at Twin Delayed Deep Deterministic Policy Gradient (TD3) algorithm using TensorFlow. It builds on what we saw in `listing8_1` for DDPG. \n",
    "\n",
    "Click here to access the paper which proposed TD3: https://arxiv.org/pdf/1802.09477.pdf\n",
    "\n",
    "TD3 is an improvement over DDPG with following changes:\n",
    "\n",
    "1) \"Twin\" - Uses clipped double Q-learning. TD3 learns two q-functions (\"twin\") and uses smaller of the two to computer bellman errors `q_target = min(q1_target, q2_target)`\n",
    "\n",
    "2) \"Delayed\" - policy updates are done at a frequency slower than Q-updates. Usually policy is updated every 2 steps of q-update.\n",
    "\n",
    "3) Target Policy smoothing - TD3 adds noise to target actions \n",
    "\n",
    "\n",
    "The basic premise is same as DDPG. TD3 is a variation of DDPG which in turn is a variation of Q-Learning with continuous action functions. When we have discrete functions, we learn Q-function for a given state and all possible actions. We then pick the best action and Q-value using `max` over all values: Q(s,a), a is all possible actions. \n",
    "\n",
    "$$a^*(s) = arg \\underset{a}{max} Q^*(s,a)$$ \n",
    "\n",
    "However, when action is continuous, we cannot find the max so easily. It becomes an optimization problem with significant costs as we have to find the max at every step.\n",
    "\n",
    "In TD3 we learn three networks, one is a policy network which takes state as input and learns to output the policy/action. Other two networks learn the Q function. However, unlike Q-learning of past, it takes state and actions as inputs and produces Q-value as output. \n",
    "\n",
    "TD# is also an off-policy. Like DDPG we use ReplayBuffer to collect the transitions and iterate over a batch to do gradient update for the policy(Actor) and Q-value(Critic) networks. \n",
    "\n",
    "Like Q-Learning, we also use target networks, both for policy as well as Q-value. The target networks are updated using polyak averaging. The complete Algorithm is as given below:\n",
    "\n",
    "***\n",
    "**Twin Delayed DDPG (TD3)**\n",
    "***\n",
    " \n",
    "1. Input initial policy parameters $\\theta$,  Q-function parameters $\\phi_1$ and $\\phi_2$, empty replay buffer D\n",
    "\n",
    "2. Set target parameters equal to online parameters $\\theta_{targ} \\leftarrow \\theta$, $\\phi_{targ,1} \\leftarrow \\phi_1$ and $\\phi_{targ,2} \\leftarrow \\phi_2$\n",
    "\n",
    "3. **repeat**\n",
    "\n",
    "4. Observe state s and select action $a = clip(\\mu_\\theta(s)+\\epsilon, a_{Low}, a_{High}), \\text{where  } \\epsilon \\sim N$\n",
    "\n",
    "5. Execute a in environment and observe next state s', reward r, and done signal d\n",
    "\n",
    "6. Store `(s,a,r,s',d)` in Replay Buffer D\n",
    "\n",
    "7. if `s'` is terminal state, reset the environment\n",
    "\n",
    "8. if it's time to update **then**:\n",
    "\n",
    "9. &emsp;&emsp;for j in range (as many updates as required):\n",
    "\n",
    "10. &emsp;&emsp;&emsp;&emsp;Sample a batch B={`(s,a,r,s',d)`} from replay Buffer D:\n",
    "\n",
    "11. &emsp;&emsp;&emsp;&emsp;Compute target actions:\n",
    "\n",
    "$$a'(s') = \\text{clip}\\left(\\mu_{\\theta_{\\text{targ}}}(s') + \\text{clip}(\\epsilon,-c,c), a_{Low}, a_{High}\\right), \\;\\;\\;\\;\\; \\epsilon \\sim \\mathcal{N}(0, \\sigma)$$\n",
    "\n",
    "12. &emsp;&emsp;&emsp;&emsp;Compute action targets: \n",
    "\n",
    "$$y(r,s',d) = r + \\gamma (1-d) \\min_{i=1,2} Q_{\\phi_{\\text{targ},i}}(s', a'(s'))$$\n",
    "\n",
    "13. &emsp;&emsp;&emsp;&emsp;Update Q function with one step gradient descent on $\\phi$: \n",
    "$$\\nabla_\\phi \\frac{1}{|B|} \\sum_{(s,a,r,s',d)\\in B}(Q_{\\phi_i}(s,a) - y(r,s',d))^2, \\;\\;\\;\\;\\;  \\text{for } i=1,2$$\n",
    "\n",
    "14. &emsp;&emsp;&emsp;&emsp;if `j mod policy_update == 0`:\n",
    "\n",
    "15. &emsp;&emsp;&emsp;&emsp;&emsp;&emsp;Update Policy with one step gradient Ascent on $\\theta$: \n",
    "\n",
    "$$\\nabla_\\theta \\frac{1}{|B|} \\sum_{s \\in B} Q_{\\phi_1}(s, \\mu_\\phi(s, \\mu_\\theta(s))$$\n",
    "\n",
    "16. &emsp;&emsp;&emsp;&emsp;&emsp;&emsp;Update target networks using polyak averaging: \n",
    "$$\\phi_{targ,i} \\leftarrow \\rho\\phi_{targ,i} + (1-\\rho)\\phi_i, \\;\\;\\;\\;\\;  \\text{for } i=1,2$$ \n",
    "$$\\theta_{targ} \\leftarrow \\rho\\theta_{targ} + (1-\\rho)\\theta$$\n",
    "***\n",
    "\n",
    "\n",
    "#### Key Features of TD3\n",
    "Similar to DDPG:\n",
    "1. TD3 is an off-policy algorithm.\n",
    "2. TD3 can only be used for environments with continuous action spaces.\n",
    "3. TD3 can be thought of as being deep Q-learning for continuous action spaces.\n",
    "\n",
    "\n",
    "\n",
    "#### Our Implementation\n",
    "THis notebook follows the code found in OpenAI's [Spinning Up Library](https://spinningup.openai.com/en/latest/algorithms/td3.html). In this notebook we have broken the code into separate code cells with required explanations. Also some of the implementations like ReplayBuffer have been borrowed from our past notebooks to provide continuity. Further some codes like building of networks have been simplified resulting in easier to understand but more verbose code. \n",
    "\n",
    "The tensorflow version implemented in this notebook uses eager evaluation under TF2 vs TF1 implementations in SPinning up Library. The code in this notebook mirrors the pytorch version and may look different from the spinning up implementations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.signal\n",
    "import matplotlib.pyplot as plt\n",
    "import itertools\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import layers \n",
    "from tensorflow.keras import Model, Input\n",
    "\n",
    "from copy import deepcopy\n",
    "import gym\n",
    "\n",
    "\n",
    "import os\n",
    "import io\n",
    "import base64\n",
    "import time\n",
    "import glob\n",
    "from IPython.display import HTML\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - Pendulum\n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are continuous. We will build it on `Pendulum-v0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name, seed=None):\n",
    "    # remove time limit wrapper from environment\n",
    "    env = gym.make(env_name).unwrapped\n",
    "    if seed is not None:\n",
    "        env.seed(seed)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State shape: (3,)\n",
      "Action shape: (1,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'Pendulum-v0'\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset()\n",
    "plt.imshow(env.render(\"rgb_array\"))\n",
    "state_shape, action_shape = env.observation_space.shape, env.action_space.shape\n",
    "print('State shape: {}'.format(state_shape))\n",
    "print('Action shape: {}'.format(action_shape))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Policy network (Actor)\n",
    "It is a simple 2 hidden layer network which takes state as input and produces action making sure that action values are within the allowed range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPActor(tf.keras.Model):\n",
    "    def __init__(self, state_dim, act_dim, act_limit):\n",
    "        super().__init__()\n",
    "        self.act_limit = act_limit\n",
    "        self.fc1 = layers.Dense(256, activation=\"relu\")\n",
    "        self.fc2 = layers.Dense(256, activation=\"relu\")\n",
    "        self.actor = layers.Dense(act_dim)\n",
    "    \n",
    "    def call(self, s):\n",
    "        x = self.fc1(s)\n",
    "        x = self.fc2(x)\n",
    "        x = self.actor(x)\n",
    "        x = tf.keras.activations.tanh(x)  # to output in range(-1,1)\n",
    "        x = self.act_limit * x\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Q-network network (Critic)\n",
    "It is a simple 2 hidden layer network which takes state and action as input and produces Q-value as output. We will have two versions of Q-network as Critic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPQFunction(tf.keras.Model):\n",
    "    def __init__(self, state_dim, act_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = layers.Dense(256, activation=\"relu\")\n",
    "        self.fc2 = layers.Dense(256, activation=\"relu\")\n",
    "        self.Q = layers.Dense(1)\n",
    "    \n",
    "    def call(self, s, a):\n",
    "        x = tf.concat([s,a], axis=-1)\n",
    "        x = self.fc1(x)\n",
    "        x = self.fc2(x)\n",
    "        q = self.Q(x)\n",
    "        return tf.squeeze(q, -1)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combine Actor and Critic into a single model\n",
    "\n",
    "One policy Network and Two Q-networks as discussed above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPActorCritic(tf.keras.Model):\n",
    "    def __init__(self, observation_space, action_space):\n",
    "        super().__init__()\n",
    "        self.state_dim = observation_space.shape[0]\n",
    "        self.act_dim = action_space.shape[0]\n",
    "        self.act_limit = action_space.high[0]\n",
    "        \n",
    "        #build Q and policy functions\n",
    "        self.q1 = MLPQFunction(self.state_dim, self.act_dim)\n",
    "        self.q2 = MLPQFunction(self.state_dim, self.act_dim)\n",
    "        self.policy = MLPActor(self.state_dim, self.act_dim, self.act_limit)\n",
    "        \n",
    "    def act(self, state):\n",
    "        return self.policy(state).numpy()\n",
    "\n",
    "    def get_action(self, s, noise_scale):\n",
    "        a = self.act(s.reshape(1,-1).astype(\"float32\")).reshape(-1)\n",
    "        a += noise_scale * np.random.randn(self.act_dim)\n",
    "        return np.clip(a, -self.act_limit, self.act_limit)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy ($\\epsilon-greedy$) to sample from the environment and store the transitions (s,a,r,s',done) into a buffer. These samples are used multiple times in a learning making the process sample efficient. \n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size=1e6):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to holde buffer\n",
    "        self.next_id = 0\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "            self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size=32):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q-loss\n",
    "\n",
    "Compute Q-loss as per equations:\n",
    "\n",
    "$$a'(s') = \\text{clip}\\left(\\mu_{\\theta_{\\text{targ}}}(s') + \\text{clip}(\\epsilon,-c,c), a_{Low}, a_{High}\\right), \\;\\;\\;\\;\\; \\epsilon \\sim \\mathcal{N}(0, \\sigma)$$\n",
    "\n",
    "$$y(r,s',d) = r + \\gamma (1-d) \\min_{i=1,2} Q_{\\phi_{\\text{targ},i}}(s', a'(s'))$$\n",
    "\n",
    " \n",
    "$$Q_{Loss, i} = \\frac{1}{|B|} \\sum_{(s,a,r,s',d)\\in B}(Q_{\\phi_i}(s,a) - y(r,s',d))^2, \\;\\;\\;\\;\\;$$\n",
    "\n",
    "$$Q_{Loss} = \\sum_{i=1,2} Q_{Loss, i}$$\n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def compute_q_loss(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma, target_noise, noise_clip, act_limit, tape):\n",
    "    \n",
    "    # convert numpy array to proper data types\n",
    "    states = states.astype('float32')\n",
    "    actions = actions.astype('float32')\n",
    "    rewards = rewards.astype('float32')\n",
    "    next_states = next_states.astype('float32')\n",
    "    done_flags = done_flags.astype('float32')\n",
    "\n",
    "    \n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    q1 = agent.q1(states, actions)\n",
    "    q2 = agent.q2(states, actions)\n",
    "    \n",
    "    # Bellman backup for Q function\n",
    "    with tape.stop_recording():\n",
    "        \n",
    "        action_target = target_network.policy(next_states)\n",
    "        \n",
    "        # Target policy smoothing\n",
    "        epsilon = tf.random.normal(action_target.shape) * target_noise\n",
    "        epsilon = tf.clip_by_value(epsilon, -noise_clip, noise_clip)\n",
    "        action_target = action_target + epsilon\n",
    "        action_target = tf.clip_by_value(action_target, -act_limit, act_limit)\n",
    "            \n",
    "            \n",
    "        q1_target = target_network.q1(next_states, action_target)\n",
    "        q2_target = target_network.q2(next_states, action_target)\n",
    "        q_target = tf.minimum(q1_target, q2_target) \n",
    "        target = rewards + gamma * (1 - done_flags) * q_target\n",
    "\n",
    "    # MSE loss against Bellman backup\n",
    "    loss_q1 = tf.reduce_mean((q1 - target)**2)\n",
    "    loss_q2 = tf.reduce_mean((q2 - target)**2)\n",
    "    loss_q = loss_q1 + loss_q2\n",
    "    \n",
    "    return loss_q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Policy-Loss\n",
    "\n",
    "Compute Policy Loss as per equation:\n",
    "    \n",
    "$$ Policy_{Loss} = - \\frac{1}{|B|} \\sum_{s \\in B} Q_{\\phi_1}(s, \\mu_\\phi(s, \\mu_\\theta(s))$$\n",
    "\n",
    "Please note the `-` sign. We need to do gradient ascent but TensorFlow does gradient descent. We convert the ascent to descent using a -ve sign. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_policy_loss(agent, states, tape):\n",
    "    \n",
    "    # convert numpy array to proper data type\n",
    "    states = states.astype('float32')\n",
    "    \n",
    "    q1_values = agent.q1(states, agent.policy(states))\n",
    "    \n",
    "    loss_policy = - tf.reduce_mean(q1_values)\n",
    "    \n",
    "    return loss_policy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### One step gradient Descent on both Policy(Actor) and Q-value(Critic)\n",
    "\n",
    "The policy update is delayed. It is updated every `policy_delay` updates of Q updates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_step_update(agent, target_network, q_params, q_optimizer, policy_optimizer, \n",
    "                    states, actions, rewards, next_states, done_flags,\n",
    "                    gamma, polyak, target_noise, noise_clip, act_limit, \n",
    "                    policy_delay, timer):\n",
    "    \n",
    "    #one step gradient for q-values\n",
    "    with tf.GradientTape() as tape:\n",
    "        loss_q = compute_q_loss(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                        gamma, target_noise, noise_clip, act_limit, tape)\n",
    "        \n",
    "        gradients = tape.gradient(loss_q, q_params)\n",
    "        q_optimizer.apply_gradients(zip(gradients, q_params))\n",
    "    \n",
    "    # Update policy and target networks after policy_delay updates of Q-networks\n",
    "    if timer % policy_delay == 0:\n",
    "        #Freeze Q-network\n",
    "        agent.q1.trainable=False \n",
    "        agent.q2.trainable=False\n",
    "\n",
    "        #one setep gradient for policy network\n",
    "        with tf.GradientTape() as tape:\n",
    "            loss_policy = compute_policy_loss(agent, states, tape)\n",
    "            gradients = tape.gradient(loss_policy, agent.policy.trainable_variables)\n",
    "            policy_optimizer.apply_gradients(zip(gradients, agent.policy.trainable_variables))\n",
    "\n",
    "        #UnFreeze Q-network\n",
    "        agent.q1.trainable=True \n",
    "        agent.q2.trainable=True\n",
    "\n",
    "        # update target networks with polyak averaging\n",
    "        updated_model_weights = []\n",
    "        for weights, weights_target in zip(agent.get_weights(), target_network.get_weights()):\n",
    "            new_weights = polyak*weights_target+(1-polyak)*weights\n",
    "            updated_model_weights.append(new_weights)\n",
    "        target_network.set_weights(updated_model_weights)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### To Test performance of agent without any noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_agent(env, agent, num_test_episodes, max_ep_len):\n",
    "    ep_rets, ep_lens = [], []\n",
    "    for j in range(num_test_episodes):\n",
    "        state, done, ep_ret, ep_len = env.reset(), False, 0, 0\n",
    "        while not(done or (ep_len == max_ep_len)):\n",
    "            # Take deterministic actions at test time (noise_scale=0)\n",
    "            state, reward, done, _ = env.step(agent.get_action(state, 0))\n",
    "            ep_ret += reward\n",
    "            ep_len += 1\n",
    "        ep_rets.append(ep_ret)\n",
    "        ep_lens.append(ep_len)\n",
    "    return np.mean(ep_rets), np.mean(ep_lens)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TD3 Algorithm\n",
    "\n",
    "We pull all the pieces together to train the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def td3(env_fn, seed=0, \n",
    "         steps_per_epoch=4000, epochs=5, replay_size=int(1e6), gamma=0.99, \n",
    "         polyak=0.995, policy_lr=1e-3, q_lr=1e-3, batch_size=100, start_steps=10000, \n",
    "         update_after=1000, update_every=50, act_noise=0.1, target_noise=0.2,\n",
    "         noise_clip=0.5, policy_delay=2, num_test_episodes=10, max_ep_len=1000):\n",
    "    \n",
    "    tf.random.set_seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    \n",
    "    env, test_env = env_fn(), env_fn()\n",
    "    \n",
    "    ep_rets, ep_lens = [], []\n",
    "\n",
    "    state_dim = env.observation_space.shape\n",
    "    act_dim = env.action_space.shape[0]\n",
    "    \n",
    "    act_limit = env.action_space.high[0]\n",
    "    \n",
    "    agent = MLPActorCritic(env.observation_space, env.action_space)\n",
    "\n",
    "    # force a build of model to initialize the model parameters\n",
    "    s = env.reset()\n",
    "    a = env.action_space.sample()    \n",
    "    agent.policy(np.array([s], dtype=np.float32))\n",
    "    agent.q1(np.array([s],dtype=np.float32),np.array([a],dtype=np.float32))\n",
    "    agent.q2(np.array([s],dtype=np.float32),np.array([a],dtype=np.float32))\n",
    "\n",
    "    # make target network as a deep copy\n",
    "    target_network = deepcopy(agent)\n",
    "    \n",
    "    # Freeze target networks with respect to optimizers (only update via polyak averaging)\n",
    "    target_network.policy.trainable=False\n",
    "    target_network.q1.trainable = False\n",
    "    target_network.q2.trainable = False\n",
    "    \n",
    "    # Experience buffer\n",
    "    replay_buffer = ReplayBuffer(replay_size)\n",
    "    \n",
    "    # List of parameters for both Q-networks \n",
    "    q_params = agent.q1.trainable_variables+agent.q2.trainable_variables\n",
    "\n",
    "    #optimizers\n",
    "    q_optimizer = tf.keras.optimizers.Adam(learning_rate=q_lr)\n",
    "    policy_optimizer = tf.keras.optimizers.Adam(learning_rate=policy_lr)\n",
    "    \n",
    "    total_steps = steps_per_epoch*epochs\n",
    "    state, ep_ret, ep_len = env.reset(), 0, 0\n",
    "    \n",
    "    for t in range(total_steps):\n",
    "        if t > start_steps:\n",
    "            action = agent.get_action(state, act_noise)\n",
    "        else:\n",
    "            action = env.action_space.sample()\n",
    "            \n",
    "        next_state, reward, done, _ = env.step(action)\n",
    "        ep_ret += reward\n",
    "        ep_len += 1\n",
    "        \n",
    "        # Ignore the \"done\" signal if it comes from hitting the time\n",
    "        # horizon (that is, when it's an artificial terminal signal\n",
    "        # that isn't based on the agent's state)\n",
    "        done = False if ep_len==max_ep_len else done\n",
    "        \n",
    "        # Store experience to replay buffer\n",
    "        replay_buffer.add(state, action, reward, next_state, done)\n",
    "        \n",
    "        state = next_state\n",
    "        \n",
    "        # End of trajectory handling\n",
    "        if done or (ep_len == max_ep_len):\n",
    "            ep_rets.append(ep_ret)\n",
    "            ep_lens.append(ep_len)\n",
    "            state, ep_ret, ep_len = env.reset(), 0, 0\n",
    "        \n",
    "        # Update handling\n",
    "        if t >= update_after and t % update_every == 0:\n",
    "            for j in range(update_every):\n",
    "                states, actions, rewards, next_states, done_flags = replay_buffer.sample(batch_size)\n",
    "                \n",
    "                one_step_update(\n",
    "                        agent, target_network, q_params, q_optimizer, policy_optimizer, \n",
    "                        states, actions, rewards, next_states, done_flags,\n",
    "                        gamma, polyak, target_noise, noise_clip, act_limit, policy_delay, j\n",
    "                )\n",
    "        \n",
    "        # End of epoch handling\n",
    "        if (t+1) % steps_per_epoch == 0:\n",
    "            epoch = (t+1) // steps_per_epoch\n",
    "            \n",
    "            avg_ret, avg_len = test_agent(test_env, agent, num_test_episodes, max_ep_len)\n",
    "            print(\"End of epoch: {:.0f}, Training Average Reward: {:.0f}, Training Average Length: {:.0f}\".format(epoch, np.mean(ep_rets), np.mean(ep_lens)))\n",
    "            print(\"End of epoch: {:.0f}, Test Average Reward: {:.0f}, Test Average Length: {:.0f}\".format(epoch, avg_ret, avg_len))\n",
    "            ep_rets, ep_lens = [], []\n",
    "    \n",
    "    return agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "End of epoch: 1, Training Average Reward: -6928, Training Average Length: 1000\n",
      "End of epoch: 1, Test Average Reward: -3891, Test Average Length: 1000\n",
      "End of epoch: 2, Training Average Reward: -6142, Training Average Length: 1000\n",
      "End of epoch: 2, Test Average Reward: -135, Test Average Length: 1000\n",
      "End of epoch: 3, Training Average Reward: -3665, Training Average Length: 1000\n",
      "End of epoch: 3, Test Average Reward: -215, Test Average Length: 1000\n",
      "End of epoch: 4, Training Average Reward: -108, Training Average Length: 1000\n",
      "End of epoch: 4, Test Average Reward: -200, Test Average Length: 1000\n",
      "End of epoch: 5, Training Average Reward: -198, Training Average Length: 1000\n",
      "End of epoch: 5, Test Average Reward: -142, Test Average Length: 1000\n"
     ]
    }
   ],
   "source": [
    "env_name = 'Pendulum-v0'\n",
    "agent = td3(lambda : make_env(env_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_animation(env, agent, save_dir):\n",
    "    \n",
    "    try:\n",
    "        env = gym.wrappers.Monitor(\n",
    "            env, save_dir, video_callable=lambda id: True, force=True, mode='evaluation')\n",
    "    except gym.error.Error as e:\n",
    "        print(e)\n",
    "\n",
    "    if not os.path.exists(save_dir):\n",
    "        os.makedirs(save_dir)\n",
    "        \n",
    "    state, done, ep_ret, ep_len = env.reset(), False, 0, 0\n",
    "    while not done:\n",
    "        # Take deterministic actions at test time (noise_scale=0)\n",
    "        state, reward, done, _ = env.step(agent.get_action(state, 0))\n",
    "        ep_ret += reward\n",
    "        ep_len += 1\n",
    "\n",
    "    print('Reward: {}'.format(ep_ret))\n",
    "    env.close()\n",
    "            \n",
    "def display_animation(filepath):\n",
    "    video = io.open(filepath, 'r+b').read()\n",
    "    encoded = base64.b64encode(video)\n",
    "    return HTML(data='''<video alt=\"test\" controls>\n",
    "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
    "                 </video>'''.format(encoded.decode('ascii')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reward: -4.149834116079809\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Animate learned policy\n",
    "save_dir='./videos/tensorflow/td3/pendulum'\n",
    "env = gym.make(env_name)\n",
    "generate_animation(env, agent, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train and evaluate performance on LunarLander Environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "End of epoch: 1, Training Average Reward: -185, Training Average Length: 102\n",
      "End of epoch: 1, Test Average Reward: -174, Test Average Length: 582\n",
      "End of epoch: 2, Training Average Reward: -227, Training Average Length: 110\n",
      "End of epoch: 2, Test Average Reward: 22, Test Average Length: 609\n",
      "End of epoch: 3, Training Average Reward: -137, Training Average Length: 160\n",
      "End of epoch: 3, Test Average Reward: -64, Test Average Length: 316\n",
      "End of epoch: 4, Training Average Reward: 34, Training Average Length: 368\n",
      "End of epoch: 4, Test Average Reward: -119, Test Average Length: 351\n",
      "End of epoch: 5, Training Average Reward: -97, Training Average Length: 253\n",
      "End of epoch: 5, Test Average Reward: -106, Test Average Length: 328\n",
      "Reward: -183.4313085795194\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Train\n",
    "env_name = 'LunarLanderContinuous-v2'\n",
    "agent1 = td3(lambda : make_env(env_name))\n",
    "\n",
    "# Animate learned policy\n",
    "save_dir='./videos/tensorflow/td3/lunar'\n",
    "env = gym.make(env_name)\n",
    "generate_animation(env, agent1, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
